home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / ofs / ofsFileDesc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-12-19  |  15.1 KB  |  535 lines
  1. /* 
  2.  * ofsFileDesc.c --
  3.  *
  4.  *    Routines to allocate, initialize, and free file descriptors for the
  5.  *      OFS domain file systems.
  6.  *
  7.  * Copyright 1987 Regents of the University of California
  8.  * All rights reserved.
  9.  * Permission to use, copy, modify, and distribute this
  10.  * software and its documentation for any purpose and without
  11.  * fee is hereby granted, provided that the above copyright
  12.  * notice appear in all copies.  The University of California
  13.  * makes no representations about the suitability of this
  14.  * software for any purpose.  It is provided "as is" without
  15.  * express or implied warranty.
  16.  */
  17.  
  18. #ifndef lint
  19. static char rcsid[] = "$Header: /cdrom/src/kernel/Cvsroot/kernel/ofs/ofsFileDesc.c,v 9.6 91/09/10 18:42:10 rab Exp $ SPRITE (Berkeley)";
  20. #endif not lint
  21.  
  22. #include <sprite.h>
  23. #include <fs.h>
  24. #include <fsutil.h>
  25. #include <fslcl.h>
  26. #include <fsNameOps.h>
  27. #include <fsio.h>
  28. #include <fsStat.h>
  29. #include <fsdm.h>
  30. #include <ofs.h>
  31. #include <stdio.h>
  32.  
  33. #define LOCKPTR (&ofsPtr->fileDescLock)
  34.  
  35. /*
  36.  * Array to provide the ability to set and extract bits out of a bitmap byte.
  37.  */
  38. static unsigned char bitmasks[8] = {0x80, 0x40, 0x20, 0x10, 0x8, 0x4, 0x2, 0x1};
  39.  
  40. int    fsdmDescSearchStarts = 0;
  41. int    fsdmDescBytesSearched = 0;
  42.  
  43. /*
  44.  *----------------------------------------------------------------------
  45.  *
  46.  * OfsFileDescAllocInit --
  47.  *
  48.  *    Initialize the data structure needed for allocation of file
  49.  *    descriptors.
  50.  *
  51.  * Results:
  52.  *    None.
  53.  *
  54.  * Side effects:
  55.  *    Memory allocated for the bit map and the bit map is read in.
  56.  *
  57.  *----------------------------------------------------------------------
  58.  */
  59.  
  60. ReturnStatus
  61. OfsFileDescAllocInit(ofsPtr)
  62.     register Ofs_Domain *ofsPtr;
  63. {
  64.     register ReturnStatus    status;
  65.  
  66.     Sync_LockInitDynamic(&(ofsPtr->fileDescLock), "Fs:fileDescLock");
  67.     /*
  68.      * Allocate the bit map.
  69.      */
  70.  
  71.     ofsPtr->fileDescBitmap = (unsigned char *) 
  72.     malloc(ofsPtr->headerPtr->fdBitmapBlocks * FS_BLOCK_SIZE);
  73.  
  74.     /* 
  75.      * Read in the bit map.
  76.      */
  77.  
  78.     status = OfsDeviceBlockIO(ofsPtr, FS_READ, 
  79.             ofsPtr->headerPtr->fdBitmapOffset * 4, 
  80.             ofsPtr->headerPtr->fdBitmapBlocks * 4,
  81.             (Address) ofsPtr->fileDescBitmap);
  82.     if (status != SUCCESS) {
  83.     printf( "Could not read in OFS file descriptor bit map.\n");
  84.     return(status);
  85.     } else {
  86.     fs_Stats.gen.physBytesRead += FS_BLOCK_SIZE;
  87.     }
  88.     return(SUCCESS);
  89. }
  90.  
  91. /*
  92.  *----------------------------------------------------------------------
  93.  *
  94.  * OfsWriteBackFileDescBitmap() --
  95.  *
  96.  *    Write the file descriptor bit map out to disk for this domain.
  97.  *
  98.  * Results:
  99.  *    Error if the write failed.
  100.  *
  101.  * Side effects:
  102.  *    None.
  103.  *
  104.  *----------------------------------------------------------------------
  105.  */
  106.  
  107. ENTRY ReturnStatus
  108. OfsWriteBackFileDescBitmap(ofsPtr)
  109.     register Ofs_Domain *ofsPtr;
  110. {
  111.     register ReturnStatus    status;
  112.  
  113.     LOCK_MONITOR;
  114.  
  115.     status = OfsDeviceBlockIO(ofsPtr, FS_WRITE,
  116.             ofsPtr->headerPtr->fdBitmapOffset * 4, 
  117.             ofsPtr->headerPtr->fdBitmapBlocks * 4,
  118.             (Address) ofsPtr->fileDescBitmap);
  119.     if (status != SUCCESS) {
  120.     printf( "Could not write out OFS file desc bit map.\n");
  121.     } else {
  122.     fs_Stats.gen.physBytesWritten += FS_BLOCK_SIZE;
  123.     }
  124.  
  125.     UNLOCK_MONITOR;
  126.     return(status);
  127. }
  128.  
  129. /*
  130.  *----------------------------------------------------------------------
  131.  *
  132.  * Ofs_GetNewFileNumber() --
  133.  *
  134.  *    Get a new file number by allocating a free file descriptor
  135.  *    from the file descriptor bitmap.
  136.  *
  137.  * Results:
  138.  *    An error if could not find a free file descriptor.
  139.  *
  140.  * Side effects:
  141.  *    fileNumberPtr is set to the number of the file descriptor allocated.
  142.  *
  143.  *----------------------------------------------------------------------
  144.  */
  145.  
  146. ENTRY ReturnStatus
  147. Ofs_GetNewFileNumber(domainPtr, dirFileNum, fileNumberPtr)
  148.     Fsdm_Domain     *domainPtr;    /* Domain to allocate the file 
  149.                      * descriptor out of. */
  150.     int            dirFileNum;    /* File number of the directory that
  151.                        the file is in.  -1 means that
  152.                        this file descriptor is being
  153.                        allocated for a directory. */
  154.     int            *fileNumberPtr; /* Place to return the number of
  155.                        the file descriptor allocated. */
  156. {
  157.     register Ofs_Domain        *ofsPtr = OFS_PTR_FROM_DOMAIN(domainPtr);
  158.     register int            i;
  159.     register int        j;
  160.     int                startByte;
  161.     register unsigned char     *bitmapPtr;
  162.     register unsigned char     *bitmaskPtr;
  163.     Boolean               found = FALSE;
  164.     int                   descBytes;
  165.  
  166.     LOCK_MONITOR;
  167.     fsdmDescSearchStarts++;
  168.     descBytes = ofsPtr->headerPtr->numFileDesc >> 3;
  169.     
  170.     if (dirFileNum == -1) {
  171.     /*
  172.      * Search linearly from a random starting byte.
  173.      */
  174.     startByte = ((Fsutil_TimeInSeconds() * 1103515245 + 12345) & 0x7fffffff) % 
  175.             descBytes;
  176.     } else {
  177.     /*
  178.      * Start search where directory is.
  179.      */
  180.     startByte = dirFileNum / 8;
  181.     }
  182.  
  183.     /*
  184.      * Linear search forward the bit map a byte at a time.
  185.      */
  186.     bitmapPtr = &(ofsPtr->fileDescBitmap[startByte]);
  187.     i = startByte;
  188.     do {
  189.     fsdmDescBytesSearched++;
  190.     if (*bitmapPtr != 0xff) {
  191.         found = TRUE;
  192.         break;
  193.     }
  194.     i++;
  195.     if (i == descBytes) {
  196.         i = 0;
  197.         bitmapPtr = ofsPtr->fileDescBitmap;
  198.     } else {
  199.         bitmapPtr++;
  200.     }
  201.     } while (i != startByte);
  202.  
  203.     if (!found) {
  204.     printf( "Out of file descriptors.\n");
  205.     UNLOCK_MONITOR;
  206.     return(FAILURE);
  207.     }
  208.  
  209.     ofsPtr->summaryInfoPtr->numFreeFileDesc--;
  210.     /*
  211.      * Now find which file descriptor is free within the byte.
  212.      */
  213.     for (j = 0, bitmaskPtr = bitmasks; 
  214.      j < 8 && (*bitmapPtr & *bitmaskPtr) != 0; 
  215.      j++, bitmaskPtr++) {
  216.     }
  217.     *fileNumberPtr = i * 8 + j;
  218.     *bitmapPtr |= *bitmaskPtr;
  219.  
  220.     UNLOCK_MONITOR;
  221.  
  222.     return(SUCCESS);
  223. }
  224.  
  225.  
  226. /*
  227.  *----------------------------------------------------------------------
  228.  *
  229.  * Ofs_FreeFileNumber() --
  230.  *
  231.  *    Free a file number by clearing the corresponding bit the in
  232.  *    file descriptor bit map.
  233.  *
  234.  * Results:
  235.  *    SUCCESS.
  236.  *
  237.  * Side effects:
  238.  *    Bit map modified.
  239.  *
  240.  *----------------------------------------------------------------------
  241.  */
  242.  
  243. ENTRY ReturnStatus
  244. Ofs_FreeFileNumber(domainPtr, fileNumber)
  245.     register Fsdm_Domain *domainPtr;    /* Domain that the file 
  246.                      * descriptor is in. */
  247.     int            fileNumber;     /* Number of file descriptor to 
  248.                        free.*/
  249. {
  250.     Ofs_Domain    *ofsPtr = OFS_PTR_FROM_DOMAIN(domainPtr);
  251.     LOCK_MONITOR;
  252.     ofsPtr->summaryInfoPtr->numFreeFileDesc++;
  253.     ofsPtr->fileDescBitmap[fileNumber / 8] &= ~bitmasks[fileNumber & 0x7];
  254.     UNLOCK_MONITOR;
  255.     return SUCCESS;
  256. }
  257.  
  258.  
  259. /*
  260.  *----------------------------------------------------------------------
  261.  *
  262.  * Ofs_FileDescInit() --
  263.  *
  264.  *    Initialize a new file descriptor.
  265.  *
  266.  * Results:
  267.  *    An error if could not read the file descriptor from disk.
  268.  *
  269.  * Side effects:
  270.  *    The file decriptor is initialized.
  271.  *
  272.  *----------------------------------------------------------------------
  273.  */
  274.  
  275. ReturnStatus
  276. Ofs_FileDescInit(domainPtr, fileNumber, type, permissions, uid, gid, fileDescPtr)
  277.     register Fsdm_Domain *domainPtr;    /* Domain of the file */
  278.     int            fileNumber;     /* Number of file descriptor */
  279.     int            type;        /* Type of the file */
  280.     int            permissions;    /* Permission bits for the file */
  281.     int            uid;        /* Owner ID for the file */
  282.     int            gid;        /* Group ID for the file */
  283.     register Fsdm_FileDescriptor    *fileDescPtr;    /* File descriptor structure to
  284.                        initialize. */
  285. {
  286.     ReturnStatus status;
  287.     register int index;
  288.  
  289.     /*
  290.      * Fetch the file descriptor and do rudimentation consistency checks.
  291.      * This also gets its block into the cache which will happen sooner
  292.      * or later anyway.
  293.      */
  294.     status = Ofs_FileDescFetch(domainPtr, fileNumber, fileDescPtr);
  295.     if (status != SUCCESS) {
  296.     return(status);
  297.     }
  298.     if (fileDescPtr->flags & FSDM_FD_ALLOC) {
  299.     printf( "Ofs_FileDescInit fetched non-free file desc\n");
  300.     return(FS_FILE_EXISTS);
  301.     }
  302.     fileDescPtr->magic = FSDM_FD_MAGIC;
  303.     fileDescPtr->flags = FSDM_FD_ALLOC|FSDM_FD_DIRTY;
  304.     fileDescPtr->fileType = type;
  305.     fileDescPtr->permissions = permissions;
  306.     fileDescPtr->uid = uid;
  307.     fileDescPtr->gid = gid;
  308.     fileDescPtr->lastByte = -1;
  309.     fileDescPtr->firstByte = -1;
  310.     fileDescPtr->userType = FS_USER_TYPE_UNDEFINED;
  311.     fileDescPtr->numLinks = 1;
  312.     fileDescPtr->numKbytes = 0;
  313.     /*
  314.      * Give this new file a new version number.  The increment is by 2 to
  315.      * ensure that a client invalidates any cache blocks associated with
  316.      * the previous incarnation of the file.  Remember that when a client
  317.      * opens for writing a version number 1 greater means that its old
  318.      * cache blocks are still ok, and also remember that clients with
  319.      * clean blocks are not told when a file is deleted.
  320.      */
  321.     fileDescPtr->version += 2;
  322.  
  323.     /*
  324.      * Clear out device info.  It is set up properly by the make-device routine.
  325.      */
  326.     fileDescPtr->devServerID = -1;
  327.     fileDescPtr->devType = -1;
  328.     fileDescPtr->devUnit = -1;
  329.  
  330.     /*
  331.      * Set the time stamps.  These times should come from the client.
  332.      */
  333.     fileDescPtr->createTime = Fsutil_TimeInSeconds();
  334.     fileDescPtr->accessTime = fileDescPtr->createTime;
  335.     fileDescPtr->descModifyTime = fileDescPtr->createTime;
  336.     fileDescPtr->dataModifyTime = fileDescPtr->createTime;
  337.  
  338.     for (index = 0; index < FSDM_NUM_DIRECT_BLOCKS ; index++) {
  339.     fileDescPtr->direct[index] = FSDM_NIL_INDEX;
  340.     }
  341.     for (index = 0; index < FSDM_NUM_INDIRECT_BLOCKS ; index++) {
  342.     fileDescPtr->indirect[index] = FSDM_NIL_INDEX;
  343.     }
  344.     return(SUCCESS);
  345. }
  346.  
  347. /*
  348.  *----------------------------------------------------------------------
  349.  *
  350.  * Ofs_FileDescFetch() --
  351.  *
  352.  *    Fetch the given file descriptor from disk and store it into
  353.  *    *fileDescPtr.
  354.  *
  355.  * Results:
  356.  *    An error if could not read the file descriptor from disk.
  357.  *
  358.  * Side effects:
  359.  *    *fileDescPtr is modified.
  360.  *
  361.  *----------------------------------------------------------------------
  362.  */
  363.  
  364. ReturnStatus
  365. Ofs_FileDescFetch(domainPtr, fileNumber, fileDescPtr)
  366.      Fsdm_Domain     *domainPtr;    /* Domain to fetch the file 
  367.                      * descriptor from. */
  368.     register int    fileNumber;     /* Number of file descriptor to 
  369.                        fetch.*/
  370.     Fsdm_FileDescriptor    *fileDescPtr;    /* File descriptor structure to
  371.                        initialize. */
  372. {
  373.     register Ofs_Domain          *ofsPtr = OFS_PTR_FROM_DOMAIN(domainPtr);
  374.     register ReturnStatus     status;
  375.     register Ofs_DomainHeader *headerPtr;
  376.     register int         blockNum;
  377.     int             offset;
  378.     Fscache_Block        *blockPtr;
  379.     Boolean            found;
  380.  
  381.     headerPtr = ofsPtr->headerPtr;
  382.     blockNum = headerPtr->fileDescOffset + fileNumber / FSDM_FILE_DESC_PER_BLOCK;
  383.     offset = (fileNumber & (FSDM_FILE_DESC_PER_BLOCK - 1)) *
  384.         FSDM_MAX_FILE_DESC_SIZE;
  385.     fs_Stats.blockCache.fileDescReads++;
  386.     Fscache_FetchBlock(&ofsPtr->physHandle.cacheInfo, blockNum, 
  387.               FSCACHE_DESC_BLOCK, &blockPtr, &found);
  388.     if (!found) {
  389.     status = OfsDeviceBlockIO(ofsPtr, FS_READ, 
  390.                blockNum * FS_FRAGMENTS_PER_BLOCK,
  391.                FS_FRAGMENTS_PER_BLOCK, blockPtr->blockAddr);
  392.     if (status != SUCCESS) {
  393.         printf( "Could not read in file descriptor\n");
  394.         Fscache_UnlockBlock(blockPtr, 0, -1, 0, FSCACHE_DELETE_BLOCK);
  395.         return(status);
  396.     } else {
  397.         fs_Stats.gen.physBytesRead += FS_BLOCK_SIZE;
  398.     }
  399.     } else {
  400.     fs_Stats.blockCache.fileDescReadHits++;
  401.     }
  402.     bcopy(blockPtr->blockAddr + offset, (Address) fileDescPtr,
  403.     sizeof(Fsdm_FileDescriptor));
  404.     Fscache_UnlockBlock(blockPtr, 0, blockNum * FS_FRAGMENTS_PER_BLOCK, 
  405.                 FS_BLOCK_SIZE, 0);
  406.  
  407.     if (fileDescPtr->magic != FSDM_FD_MAGIC) {
  408.     printf( "Fsdm_FileDescFetch found junky file desc\n");
  409.     return(FAILURE);
  410.     } else {
  411.     return(SUCCESS);
  412.     }
  413. }
  414.  
  415.  
  416. /*
  417.  *----------------------------------------------------------------------
  418.  *
  419.  * Ofs_FileDescStore() --
  420.  *
  421.  *    Store the given file descriptor back into the file system block
  422.  *    where it came from.  This involves putting the block back into
  423.  *    the cache.
  424.  *
  425.  * Results:
  426.  *    An error if could not read the file descriptor from disk.
  427.  *
  428.  * Side effects:
  429.  *    Cache block is modified.
  430.  *
  431.  *----------------------------------------------------------------------
  432.  */
  433.  
  434. ReturnStatus
  435. Ofs_FileDescStore(domainPtr, handlePtr, fileNumber, fileDescPtr, forceOut)
  436.     register Fsdm_Domain *domainPtr;    /* Domain to store the file 
  437.                      * descriptor into. */
  438.     Fsio_FileIOHandle    *handlePtr;
  439.     int            fileNumber;     /* Number of file descriptor to 
  440.                        store.*/
  441.     Fsdm_FileDescriptor    *fileDescPtr;     /* File descriptor to store. */
  442.     Boolean        forceOut;  /* Force the change to disk. */
  443. {
  444.     Ofs_Domain    *ofsPtr = OFS_PTR_FROM_DOMAIN(domainPtr);
  445.     register ReturnStatus   status = SUCCESS;
  446.     register Ofs_DomainHeader *headerPtr;
  447.     register int         blockNum;
  448.     int             offset;
  449.     Fscache_Block        *blockPtr;
  450.     Boolean            found;
  451.  
  452.     headerPtr = ofsPtr->headerPtr;
  453.     blockNum = headerPtr->fileDescOffset + fileNumber / FSDM_FILE_DESC_PER_BLOCK;
  454.     offset = (fileNumber & (FSDM_FILE_DESC_PER_BLOCK - 1)) *
  455.         FSDM_MAX_FILE_DESC_SIZE;
  456.     fs_Stats.blockCache.fileDescWrites++;
  457.     Fscache_FetchBlock(&ofsPtr->physHandle.cacheInfo, blockNum, 
  458.               (int)(FSCACHE_IO_IN_PROGRESS | FSCACHE_DESC_BLOCK),
  459.               &blockPtr, &found);
  460.     if (!found) {
  461.     status = OfsDeviceBlockIO(ofsPtr, FS_READ, 
  462.                blockNum * FS_FRAGMENTS_PER_BLOCK,
  463.                FS_FRAGMENTS_PER_BLOCK, blockPtr->blockAddr);
  464.     if (status != SUCCESS) {
  465.         printf( "Could not read in file descriptor\n");
  466.         Fscache_UnlockBlock(blockPtr, 0, blockNum * FS_FRAGMENTS_PER_BLOCK,
  467.                 FS_BLOCK_SIZE, FSCACHE_DELETE_BLOCK);
  468.         return(status);
  469.     } else {
  470.         fs_Stats.gen.physBytesWritten += FS_BLOCK_SIZE;
  471.     }
  472.     } else {
  473.     fs_Stats.blockCache.fileDescWriteHits++;
  474.     }
  475.     fileDescPtr->flags &= ~FSDM_FD_DIRTY;
  476.     bcopy((Address) fileDescPtr, blockPtr->blockAddr + offset, sizeof(Fsdm_FileDescriptor));
  477.     /*
  478.      * Put the block back into the cache setting the modify time to 1 which
  479.      * will guarantee that the next time the cache is written back this block
  480.      * is written back as well.
  481.      */
  482.     Fscache_UnlockBlock(blockPtr, 1, blockNum * FS_FRAGMENTS_PER_BLOCK,
  483.             FS_BLOCK_SIZE, 0);
  484.     if ((status == SUCCESS) && forceOut) { 
  485.     int    blocksSkipped;
  486.     status = Fscache_FileWriteBack(&ofsPtr->physHandle.cacheInfo,
  487.             blockNum, blockNum, FSCACHE_FILE_WB_WAIT, &blocksSkipped);
  488.     if (status != SUCCESS) {
  489.         printf("Ofs_FileDescStore: Couldn't write back desc <%d,%d>\n",
  490.             domainPtr->domainNumber, fileNumber);
  491.     }
  492.     }
  493.  
  494.     return(status);
  495. }
  496.  
  497. /*
  498.  *----------------------------------------------------------------------
  499.  *
  500.  * Ofs_FileDescSync() --
  501.  *
  502.  *    Sync any cached file descriptor to disk.
  503.  *
  504.  * Results:
  505.  *    An error if could not read the file descriptor from disk.
  506.  *
  507.  * Side effects:
  508.  *    Cache block is modified.
  509.  *
  510.  *----------------------------------------------------------------------
  511.  */
  512. ReturnStatus
  513. Ofs_FileDescSync(domainPtr, fileNumber)
  514.     register Fsdm_Domain     *domainPtr;    /* Domain to store the file 
  515.                      * descriptor into. */
  516.     int            fileNumber;     /* Number of file descriptor to 
  517.                        store.*/
  518. {
  519.     Ofs_Domain    *ofsPtr = OFS_PTR_FROM_DOMAIN(domainPtr);
  520.     ReturnStatus status;
  521.     int    blocksSkipped;
  522.     int    blockNum;
  523.  
  524.     blockNum = ofsPtr->headerPtr->fileDescOffset + 
  525.                 fileNumber / FSDM_FILE_DESC_PER_BLOCK;
  526.     status = Fscache_FileWriteBack(&ofsPtr->physHandle.cacheInfo,
  527.         blockNum, blockNum, FSCACHE_FILE_WB_WAIT, &blocksSkipped);
  528.     if (status != SUCCESS) {
  529.     printf("Ofs_FileDescSync: Couldn't sync back desc <%d,%d>\n",
  530.         domainPtr->domainNumber, fileNumber);
  531.     }
  532.     return status;
  533.  
  534. }
  535.